package com.lantosec.hmrp.modules.internal.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lantosec.hmrp.core.kit.PageVO;
import com.lantosec.hmrp.core.shiro.TokenUtil;
import com.lantosec.hmrp.core.util.DateUtils;
import com.lantosec.hmrp.modules.internal.entity.*;
import com.lantosec.hmrp.modules.internal.mapper.InternalPlanMapper;
import com.lantosec.hmrp.modules.internal.service.IInternalPlanService;
import com.lantosec.hmrp.modules.internal.vo.InternalPlanVO;
import lombok.extern.log4j.Log4j2;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * <p>
 * 评价方案 服务实现类
 * </p>
 *
 * @author AutoCode
 * @since 2020-04-23
 */
@Service
@Primary
@Log4j2
public class InternalPlanServiceImpl extends ServiceImpl<InternalPlanMapper, InternalPlan> implements IInternalPlanService {

    @Override
    public PageVO<InternalPlanVO> getAll(PageVO<InternalPlan> page, String internalPlanName, Integer internalPlanType) {
        //查询考评方案基本信息
        PageVO<InternalPlanVO> pageVO = new PageVO<>();
        page = this.page(page,new QueryWrapper<InternalPlan>().like(internalPlanName != null,InternalPlan.ColName.internal_plan_name.toString(),internalPlanName)
                .eq(internalPlanType != null,InternalPlan.ColName.internal_plan_type.toString(),internalPlanType)
                .orderByDesc(InternalPlan.ColName.create_time.toString()));
        List<InternalPlan> internalPlanList = page.getRecords();
        List<InternalPlanVO> internalPlanVOS = new ArrayList<>();
        internalPlanList.forEach(parm->{
            Integer internalPlanId = parm.getInternalPlanId();
            Integer executorMode = parm.getExecutorMode();
            Integer targetMode = parm.getTargetMode();
            InternalPlanVO internalPlanVO = parm.convertToVO();
            //组装考评方案信息
            internalPlanVO = getInternalPlanVos(parm);
            internalPlanVOS.add(internalPlanVO);
        });
        pageVO.setRecords(internalPlanVOS);
        pageVO.setTotal(page.getTotal());
        pageVO.setPageNo(page.getPageNo());
        pageVO.setPageSize(page.getPageSize());
        return pageVO;
    }

    private InternalPlanVO getInternalPlanVos(InternalPlan internalPlan) {
        InternalPlanVO internalPlanVO = internalPlan.convertToVO();
        return getInternalPlanVO(internalPlanVO.getInternalPlanId(), internalPlanVO.getExecutorMode(), internalPlanVO.getTargetMode(), internalPlanVO);
    }

    @Override
    public InternalPlanVO getInternalPlanVo(Integer internalPlanId) {
        InternalPlan internalPlan = this.getById(internalPlanId);
        InternalPlanVO internalPlanVO = internalPlan.convertToVO();
        Integer executorMode = internalPlan.getExecutorMode();
        Integer targetMode = internalPlan.getTargetMode();
        return getInternalPlanVO(internalPlanId, executorMode, targetMode, internalPlanVO);
    }

    private InternalPlanVO getInternalPlanVO(Integer internalPlanId, Integer executorMode, Integer targetMode, InternalPlanVO internalPlanVO) {
        //查询考评方案项目
        List<InternalPlanItem> internalPlanItemList = baseMapper.getInternalPlanItem(internalPlanId);
        //查询考评方案的评价方
        List<InternalPlanExecutor> internalPlanExecutorList = baseMapper.getInternalPlanExecutor(internalPlanId,executorMode);
        internalPlanExecutorList.forEach(param->{
            //如果评价方是部门
            if(param.getExecutorMode() == 1){
                param.setExecutorId(param.getDeptId());
                param.setName(param.getDeptName());
            }
            //如果评价方是岗位
            if(param.getExecutorMode() == 2){
                param.setExecutorId(param.getDeptId()+"-"+param.getPositionId());
                param.setName(param.getDeptName()+"-"+param.getPositionName());
            }
            //如果评价方是人员
            if(param.getExecutorMode() == 3){
                param.setExecutorId(param.getDeptId()+"-"+param.getUserId());
                param.setName(param.getDeptName()+"-"+param.getName());
            }
        });
        //查询考评方案的被评价方
        List<InternalPlanTarget> internalPlanTargetList = baseMapper.getInternalPlanTarget(internalPlanId,targetMode);
        internalPlanTargetList.forEach(param->{
            //如果评价方是部门
            if(param.getTargetMode() == 1){
                param.setTargetId(param.getDeptId());
                param.setName(param.getDeptName());
            }
            //如果评价方是岗位
            if(param.getTargetMode() == 2){
                param.setTargetId(param.getDeptId()+"-"+param.getPositionId());
                param.setName(param.getDeptName()+"-"+param.getPositionName());
            }
            //如果评价方是人员
            if(param.getTargetMode() == 3){
                param.setTargetId(param.getDeptId()+"-"+param.getUserId());
                param.setName(param.getDeptName()+"-"+param.getName());
            }
        });
        //查询考评方案的评价等级
        List<InternalPlanLevel> internalPlanLevelList = baseMapper.getInternalPlanLevel(internalPlanId);
        internalPlanVO.setInternalPlanItemList(internalPlanItemList);
        internalPlanVO.setInternalPlanExecutorList(internalPlanExecutorList);
        internalPlanVO.setInternalPlanTargetList(internalPlanTargetList);
        internalPlanVO.setInternalPlanLevelList(internalPlanLevelList);
        return internalPlanVO;
    }

    @Override
    public Integer saveInternalPlan(InternalPlanList internalPlanList) {
        //新增考评方案基本信息
        InternalPlan internalPlan = internalPlanList.getInternalPlan();
        if(Objects.nonNull(internalPlan)){
            saveInternalPlanInfo(internalPlan);
        }
        //新增考评方案项目
        List<InternalPlanItem> internalPlanItemList = internalPlanList.getInternalPlanItemList();
        if(CollectionUtils.isNotEmpty(internalPlanItemList)){
            internalPlanItemList.forEach(parm->{
                parm.setInternalPlanId(internalPlan.getInternalPlanId());
                baseMapper.saveInternalPlanItem(parm);
            });
        }

        //新增考评方案考评方
        List<InternalPlanExecutor> internalPlanExecutorList = internalPlanList.getInternalPlanExecutorList();
        if(CollectionUtils.isNotEmpty(internalPlanExecutorList)){
            saveInternalPlanExecutor(internalPlan, internalPlanExecutorList);
        }

        //新增考评方案被考评方
        List<InternalPlanTarget> internalPlanTargetList = internalPlanList.getInternalPlanTargetList();
        if(CollectionUtils.isNotEmpty(internalPlanTargetList)){
            saveInternalPlanTarget(internalPlan, internalPlanTargetList);
        }

        //新增考评方案的评价等级
        List<InternalPlanLevel> internalPlanLevelList = internalPlanList.getInternalPlanLevelList();
        if(CollectionUtils.isNotEmpty(internalPlanLevelList)){
            internalPlanLevelList.forEach(parm->{
                parm.setInternalPlanId(internalPlan.getInternalPlanId());
                baseMapper.saveInternalPlanLevel(parm);
            });
        }
        return internalPlan.getInternalPlanId();
    }



    /**
     * 新增考评方案基本信息
     * @param internalPlan
     */
    private void saveInternalPlanInfo(InternalPlan internalPlan) {
        internalPlan.setState(2);
        //获取当前用户id和名称
        String userId = TokenUtil.getUserId();
        String userName = TokenUtil.getName();
        internalPlan.setCreateUser(userName);
        internalPlan.setCreateUserId(userId);
        internalPlan.setCreateTime(DateUtils.nowDate());
        if(internalPlan.getTargetMode() == null){
            internalPlan.setTargetMode(3);
        }
        this.save(internalPlan);
    }

    /**
     * 新增考评方案被考评方
     * @param internalPlan
     * @param internalPlanTargetList
     */
    private void saveInternalPlanTarget(InternalPlan internalPlan, List<InternalPlanTarget> internalPlanTargetList) {
        //如果新增考评方案是科间或者自定义
        if(null != internalPlanTargetList && internalPlanTargetList.size() > 0){
            internalPlanTargetList.forEach(parm->{
                parm.setInternalPlanId(internalPlan.getInternalPlanId());
                Integer targetMode = parm.getTargetMode();
                //如果考评方是部门
                if(targetMode == 1){
                    parm.setDeptId(parm.getTargetId());
                }
                //如果考评方是岗位
                if(targetMode == 2){
                    String[] targetId = parm.getTargetId().split("-");
                    parm.setDeptId(targetId[0]);
                    parm.setPositionId(targetId[1]);
                }
                //如果考评方是人员
                if(targetMode == 3){
                    String[] targetId = parm.getTargetId().split("-");
                    parm.setDeptId(targetId[0]);
                    parm.setUserId(targetId[1]);
                }
                baseMapper.saveInternalPlanTarget(parm);
            });
        }
    }

    /**
     * 新增考评方
     * @param internalPlan
     * @param internalPlanExecutorList
     */
    private void saveInternalPlanExecutor(InternalPlan internalPlan, List<InternalPlanExecutor> internalPlanExecutorList) {
        internalPlanExecutorList.forEach(parm->{
            parm.setInternalPlanId(internalPlan.getInternalPlanId());
            Integer executorMode = parm.getExecutorMode();
            //如果考评方是部门
            if(executorMode == 1){
                parm.setDeptId(parm.getExecutorId());
            }
            //如果考评方是岗位
            if(executorMode == 2){
                String[] executorId = parm.getExecutorId().split("-");
                parm.setDeptId(executorId[0]);
                parm.setPositionId(executorId[1]);
            }
            //如果考评方是人员
            if(executorMode == 3){
                String[] executorId = parm.getExecutorId().split("-");
                parm.setDeptId(executorId[0]);
                parm.setUserId(executorId[1]);
            }
            baseMapper.saveInternalPlanExecutor(parm);
        });
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateInternalPlan(InternalPlanList internalPlanList) {
        //修改考评方案基本信息
        InternalPlan internalPlan = internalPlanList.getInternalPlan();
        //获得当前用户的名称和id
        String userId = TokenUtil.getUserId();
        String name = TokenUtil.getName();
        internalPlan.setEditorUserId(userId);
        internalPlan.setEditorUser(name);
        internalPlan.setEditorTime(DateUtils.nowDate());
        this.updateById(internalPlan);
        //修改考评方案项目，先删除后新增
        baseMapper.deleteInternalPlanItem(internalPlan.getInternalPlanId());
        List<InternalPlanItem> internalPlanItemList = internalPlanList.getInternalPlanItemList();
        internalPlanItemList.forEach(parm->{
            parm.setInternalPlanId(internalPlan.getInternalPlanId());
            baseMapper.saveInternalPlanItem(parm);
        });
        //修改考评方案考评方，先删除后新增
        baseMapper.deleteInternalPlanExecutor(internalPlan.getInternalPlanId());
        List<InternalPlanExecutor> internalPlanExecutorList = internalPlanList.getInternalPlanExecutorList();
        saveInternalPlanExecutor(internalPlan, internalPlanExecutorList);

        //修改考评方案被考评方，先删除后新增
        baseMapper.deleteInternalPlanTarget(internalPlan.getInternalPlanId());
        List<InternalPlanTarget> internalPlanTargetList = internalPlanList.getInternalPlanTargetList();
        saveInternalPlanTarget(internalPlan, internalPlanTargetList);

        //修改考评方案的评价等级，先删除后新增
        baseMapper.deleteInternalPlanLevel(internalPlan.getInternalPlanId());
        List<InternalPlanLevel> internalPlanLevelList = internalPlanList.getInternalPlanLevelList();
        internalPlanLevelList.forEach(parm->{
            parm.setInternalPlanId(internalPlan.getInternalPlanId());
            baseMapper.saveInternalPlanLevel(parm);
        });
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteInternalPlan(Integer internalPlanId) {
        //删除考评方案基本信息
        this.removeById(internalPlanId);
        //删除考评方案项目
        baseMapper.deleteInternalPlanItem(internalPlanId);
        //删除考评方案考评方
        baseMapper.deleteInternalPlanExecutor(internalPlanId);
        //删除考评方案被考评方
        baseMapper.deleteInternalPlanTarget(internalPlanId);
        //删除考评方案的评价等级
        baseMapper.deleteInternalPlanLevel(internalPlanId);
    }
}
